#include"dao_gsl_statistics.h"

DAO_INIT_MODULE;
DaoVmSpace *__daoVmSpace = NULL;

#ifdef __cplusplus
extern "C"{
#endif

static DaoNumItem constNumbers[] =
{

  { NULL, 0, 0 }
};
static void dao__gsl_stats_char_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_char_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wmean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wsd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wvariance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wsd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wtss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wtss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wabsdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wskew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wkurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wvariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wsd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wabsdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wskew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_wkurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wmean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wsd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wvariance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wsd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wtss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wtss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wabsdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wskew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wkurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wvariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wsd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wabsdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wskew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_wkurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_float_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_int_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wmean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wsd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wvariance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wsd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wtss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wtss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wabsdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wskew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wkurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wvariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wsd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wabsdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wskew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_wkurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_long_double_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_short_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uchar_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_uint_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ulong_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_variance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_tss( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_tss_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_absdev( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_skew( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_kurtosis( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_covariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_correlation( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_variance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_sd_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_absdev_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_covariance_m( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_pvariance( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_ttest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_max( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_min( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_minmax( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_max_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_min_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_minmax_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_stats_ushort_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n );

static DaoFuncItem dao_Funcs[] =
{
  { dao__gsl_stats_char_mean, "gsl_stats_char_mean( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_variance, "gsl_stats_char_variance( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_sd, "gsl_stats_char_sd( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_variance_with_fixed_mean, "gsl_stats_char_variance_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_char_sd_with_fixed_mean, "gsl_stats_char_sd_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_char_tss, "gsl_stats_char_tss( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_tss_m, "gsl_stats_char_tss_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_char_absdev, "gsl_stats_char_absdev( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_skew, "gsl_stats_char_skew( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_kurtosis, "gsl_stats_char_kurtosis( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_lag1_autocorrelation, "gsl_stats_char_lag1_autocorrelation( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_covariance, "gsl_stats_char_covariance( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_char_correlation, "gsl_stats_char_correlation( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_char_variance_m, "gsl_stats_char_variance_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_char_sd_m, "gsl_stats_char_sd_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_char_absdev_m, "gsl_stats_char_absdev_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_char_skew_m_sd, "gsl_stats_char_skew_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_char_kurtosis_m_sd, "gsl_stats_char_kurtosis_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_char_lag1_autocorrelation_m, "gsl_stats_char_lag1_autocorrelation_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_char_covariance_m, "gsl_stats_char_covariance_m( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_char_pvariance, "gsl_stats_char_pvariance( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_char_ttest, "gsl_stats_char_ttest( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_char_max, "gsl_stats_char_max( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_char_min, "gsl_stats_char_min( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_char_minmax, "gsl_stats_char_minmax( min : string, max : string, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_char_max_index, "gsl_stats_char_max_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_char_min_index, "gsl_stats_char_min_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_char_minmax_index, "gsl_stats_char_minmax_index( min_index : int, max_index : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_char_median_from_sorted_data, "gsl_stats_char_median_from_sorted_data( sorted_data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_char_quantile_from_sorted_data, "gsl_stats_char_quantile_from_sorted_data( sorted_data : array<int>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_mean, "gsl_stats_mean( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_variance, "gsl_stats_variance( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_sd, "gsl_stats_sd( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_variance_with_fixed_mean, "gsl_stats_variance_with_fixed_mean( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_sd_with_fixed_mean, "gsl_stats_sd_with_fixed_mean( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_tss, "gsl_stats_tss( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_tss_m, "gsl_stats_tss_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_absdev, "gsl_stats_absdev( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_skew, "gsl_stats_skew( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_kurtosis, "gsl_stats_kurtosis( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_lag1_autocorrelation, "gsl_stats_lag1_autocorrelation( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_covariance, "gsl_stats_covariance( data1 : array<double>, stride1 : int, data2 : array<double>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_correlation, "gsl_stats_correlation( data1 : array<double>, stride1 : int, data2 : array<double>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_variance_m, "gsl_stats_variance_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_sd_m, "gsl_stats_sd_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_absdev_m, "gsl_stats_absdev_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_skew_m_sd, "gsl_stats_skew_m_sd( data : array<double>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_kurtosis_m_sd, "gsl_stats_kurtosis_m_sd( data : array<double>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_lag1_autocorrelation_m, "gsl_stats_lag1_autocorrelation_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_covariance_m, "gsl_stats_covariance_m( data1 : array<double>, stride1 : int, data2 : array<double>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_wmean, "gsl_stats_wmean( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_wvariance, "gsl_stats_wvariance( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_wsd, "gsl_stats_wsd( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_wvariance_with_fixed_mean, "gsl_stats_wvariance_with_fixed_mean( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_wsd_with_fixed_mean, "gsl_stats_wsd_with_fixed_mean( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_wtss, "gsl_stats_wtss( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_wtss_m, "gsl_stats_wtss_m( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_wabsdev, "gsl_stats_wabsdev( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_wskew, "gsl_stats_wskew( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_wkurtosis, "gsl_stats_wkurtosis( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_wvariance_m, "gsl_stats_wvariance_m( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_wsd_m, "gsl_stats_wsd_m( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_wabsdev_m, "gsl_stats_wabsdev_m( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_wskew_m_sd, "gsl_stats_wskew_m_sd( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double, wsd : double )=>double" },
  { dao__gsl_stats_wkurtosis_m_sd, "gsl_stats_wkurtosis_m_sd( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double, wsd : double )=>double" },
  { dao__gsl_stats_pvariance, "gsl_stats_pvariance( data1 : array<double>, stride1 : int, n1 : int, data2 : array<double>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_ttest, "gsl_stats_ttest( data1 : array<double>, stride1 : int, n1 : int, data2 : array<double>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_max, "gsl_stats_max( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_min, "gsl_stats_min( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_minmax, "gsl_stats_minmax( min : double, max : double, data : array<double>, stride : int, n : int )" },
  { dao__gsl_stats_max_index, "gsl_stats_max_index( data : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_stats_min_index, "gsl_stats_min_index( data : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_stats_minmax_index, "gsl_stats_minmax_index( min_index : int, max_index : int, data : array<double>, stride : int, n : int )" },
  { dao__gsl_stats_median_from_sorted_data, "gsl_stats_median_from_sorted_data( sorted_data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_quantile_from_sorted_data, "gsl_stats_quantile_from_sorted_data( sorted_data : array<double>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_float_mean, "gsl_stats_float_mean( data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_variance, "gsl_stats_float_variance( data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_sd, "gsl_stats_float_sd( data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_variance_with_fixed_mean, "gsl_stats_float_variance_with_fixed_mean( data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_sd_with_fixed_mean, "gsl_stats_float_sd_with_fixed_mean( data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_tss, "gsl_stats_float_tss( data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_tss_m, "gsl_stats_float_tss_m( data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_absdev, "gsl_stats_float_absdev( data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_skew, "gsl_stats_float_skew( data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_kurtosis, "gsl_stats_float_kurtosis( data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_lag1_autocorrelation, "gsl_stats_float_lag1_autocorrelation( data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_covariance, "gsl_stats_float_covariance( data1 : array<float>, stride1 : int, data2 : array<float>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_float_correlation, "gsl_stats_float_correlation( data1 : array<float>, stride1 : int, data2 : array<float>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_float_variance_m, "gsl_stats_float_variance_m( data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_sd_m, "gsl_stats_float_sd_m( data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_absdev_m, "gsl_stats_float_absdev_m( data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_skew_m_sd, "gsl_stats_float_skew_m_sd( data : array<float>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_float_kurtosis_m_sd, "gsl_stats_float_kurtosis_m_sd( data : array<float>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_float_lag1_autocorrelation_m, "gsl_stats_float_lag1_autocorrelation_m( data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_covariance_m, "gsl_stats_float_covariance_m( data1 : array<float>, stride1 : int, data2 : array<float>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_float_wmean, "gsl_stats_float_wmean( w : array<float>, wstride : int, data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_wvariance, "gsl_stats_float_wvariance( w : array<float>, wstride : int, data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_wsd, "gsl_stats_float_wsd( w : array<float>, wstride : int, data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_wvariance_with_fixed_mean, "gsl_stats_float_wvariance_with_fixed_mean( w : array<float>, wstride : int, data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_wsd_with_fixed_mean, "gsl_stats_float_wsd_with_fixed_mean( w : array<float>, wstride : int, data : array<float>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_float_wtss, "gsl_stats_float_wtss( w : array<float>, wstride : int, data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_wtss_m, "gsl_stats_float_wtss_m( w : array<float>, wstride : int, data : array<float>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_float_wabsdev, "gsl_stats_float_wabsdev( w : array<float>, wstride : int, data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_wskew, "gsl_stats_float_wskew( w : array<float>, wstride : int, data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_wkurtosis, "gsl_stats_float_wkurtosis( w : array<float>, wstride : int, data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_wvariance_m, "gsl_stats_float_wvariance_m( w : array<float>, wstride : int, data : array<float>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_float_wsd_m, "gsl_stats_float_wsd_m( w : array<float>, wstride : int, data : array<float>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_float_wabsdev_m, "gsl_stats_float_wabsdev_m( w : array<float>, wstride : int, data : array<float>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_float_wskew_m_sd, "gsl_stats_float_wskew_m_sd( w : array<float>, wstride : int, data : array<float>, stride : int, n : int, wmean : double, wsd : double )=>double" },
  { dao__gsl_stats_float_wkurtosis_m_sd, "gsl_stats_float_wkurtosis_m_sd( w : array<float>, wstride : int, data : array<float>, stride : int, n : int, wmean : double, wsd : double )=>double" },
  { dao__gsl_stats_float_pvariance, "gsl_stats_float_pvariance( data1 : array<float>, stride1 : int, n1 : int, data2 : array<float>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_float_ttest, "gsl_stats_float_ttest( data1 : array<float>, stride1 : int, n1 : int, data2 : array<float>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_float_max, "gsl_stats_float_max( data : array<float>, stride : int, n : int )=>float" },
  { dao__gsl_stats_float_min, "gsl_stats_float_min( data : array<float>, stride : int, n : int )=>float" },
  { dao__gsl_stats_float_minmax, "gsl_stats_float_minmax( min : float, max : float, data : array<float>, stride : int, n : int )" },
  { dao__gsl_stats_float_max_index, "gsl_stats_float_max_index( data : array<float>, stride : int, n : int )=>int" },
  { dao__gsl_stats_float_min_index, "gsl_stats_float_min_index( data : array<float>, stride : int, n : int )=>int" },
  { dao__gsl_stats_float_minmax_index, "gsl_stats_float_minmax_index( min_index : int, max_index : int, data : array<float>, stride : int, n : int )" },
  { dao__gsl_stats_float_median_from_sorted_data, "gsl_stats_float_median_from_sorted_data( sorted_data : array<float>, stride : int, n : int )=>double" },
  { dao__gsl_stats_float_quantile_from_sorted_data, "gsl_stats_float_quantile_from_sorted_data( sorted_data : array<float>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_int_mean, "gsl_stats_int_mean( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_variance, "gsl_stats_int_variance( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_sd, "gsl_stats_int_sd( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_variance_with_fixed_mean, "gsl_stats_int_variance_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_int_sd_with_fixed_mean, "gsl_stats_int_sd_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_int_tss, "gsl_stats_int_tss( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_tss_m, "gsl_stats_int_tss_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_int_absdev, "gsl_stats_int_absdev( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_skew, "gsl_stats_int_skew( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_kurtosis, "gsl_stats_int_kurtosis( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_lag1_autocorrelation, "gsl_stats_int_lag1_autocorrelation( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_covariance, "gsl_stats_int_covariance( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_int_correlation, "gsl_stats_int_correlation( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_int_variance_m, "gsl_stats_int_variance_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_int_sd_m, "gsl_stats_int_sd_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_int_absdev_m, "gsl_stats_int_absdev_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_int_skew_m_sd, "gsl_stats_int_skew_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_int_kurtosis_m_sd, "gsl_stats_int_kurtosis_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_int_lag1_autocorrelation_m, "gsl_stats_int_lag1_autocorrelation_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_int_covariance_m, "gsl_stats_int_covariance_m( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_int_pvariance, "gsl_stats_int_pvariance( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_int_ttest, "gsl_stats_int_ttest( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_int_max, "gsl_stats_int_max( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_int_min, "gsl_stats_int_min( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_int_minmax, "gsl_stats_int_minmax( min : int, max : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_int_max_index, "gsl_stats_int_max_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_int_min_index, "gsl_stats_int_min_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_int_minmax_index, "gsl_stats_int_minmax_index( min_index : int, max_index : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_int_median_from_sorted_data, "gsl_stats_int_median_from_sorted_data( sorted_data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_int_quantile_from_sorted_data, "gsl_stats_int_quantile_from_sorted_data( sorted_data : array<int>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_long_mean, "gsl_stats_long_mean( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_variance, "gsl_stats_long_variance( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_sd, "gsl_stats_long_sd( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_variance_with_fixed_mean, "gsl_stats_long_variance_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_sd_with_fixed_mean, "gsl_stats_long_sd_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_tss, "gsl_stats_long_tss( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_tss_m, "gsl_stats_long_tss_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_absdev, "gsl_stats_long_absdev( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_skew, "gsl_stats_long_skew( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_kurtosis, "gsl_stats_long_kurtosis( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_lag1_autocorrelation, "gsl_stats_long_lag1_autocorrelation( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_covariance, "gsl_stats_long_covariance( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_long_correlation, "gsl_stats_long_correlation( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_long_variance_m, "gsl_stats_long_variance_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_sd_m, "gsl_stats_long_sd_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_absdev_m, "gsl_stats_long_absdev_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_skew_m_sd, "gsl_stats_long_skew_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_long_kurtosis_m_sd, "gsl_stats_long_kurtosis_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_long_lag1_autocorrelation_m, "gsl_stats_long_lag1_autocorrelation_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_covariance_m, "gsl_stats_long_covariance_m( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_long_pvariance, "gsl_stats_long_pvariance( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_long_ttest, "gsl_stats_long_ttest( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_long_max, "gsl_stats_long_max( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_long_min, "gsl_stats_long_min( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_long_minmax, "gsl_stats_long_minmax( min : int, max : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_long_max_index, "gsl_stats_long_max_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_long_min_index, "gsl_stats_long_min_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_long_minmax_index, "gsl_stats_long_minmax_index( min_index : int, max_index : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_long_median_from_sorted_data, "gsl_stats_long_median_from_sorted_data( sorted_data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_quantile_from_sorted_data, "gsl_stats_long_quantile_from_sorted_data( sorted_data : array<int>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_long_double_mean, "gsl_stats_long_double_mean( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_variance, "gsl_stats_long_double_variance( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_sd, "gsl_stats_long_double_sd( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_variance_with_fixed_mean, "gsl_stats_long_double_variance_with_fixed_mean( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_sd_with_fixed_mean, "gsl_stats_long_double_sd_with_fixed_mean( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_tss, "gsl_stats_long_double_tss( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_tss_m, "gsl_stats_long_double_tss_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_absdev, "gsl_stats_long_double_absdev( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_skew, "gsl_stats_long_double_skew( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_kurtosis, "gsl_stats_long_double_kurtosis( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_lag1_autocorrelation, "gsl_stats_long_double_lag1_autocorrelation( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_covariance, "gsl_stats_long_double_covariance( data1 : array<double>, stride1 : int, data2 : array<double>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_long_double_correlation, "gsl_stats_long_double_correlation( data1 : array<double>, stride1 : int, data2 : array<double>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_long_double_variance_m, "gsl_stats_long_double_variance_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_sd_m, "gsl_stats_long_double_sd_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_absdev_m, "gsl_stats_long_double_absdev_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_skew_m_sd, "gsl_stats_long_double_skew_m_sd( data : array<double>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_long_double_kurtosis_m_sd, "gsl_stats_long_double_kurtosis_m_sd( data : array<double>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_long_double_lag1_autocorrelation_m, "gsl_stats_long_double_lag1_autocorrelation_m( data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_covariance_m, "gsl_stats_long_double_covariance_m( data1 : array<double>, stride1 : int, data2 : array<double>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_long_double_wmean, "gsl_stats_long_double_wmean( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_wvariance, "gsl_stats_long_double_wvariance( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_wsd, "gsl_stats_long_double_wsd( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_wvariance_with_fixed_mean, "gsl_stats_long_double_wvariance_with_fixed_mean( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_wsd_with_fixed_mean, "gsl_stats_long_double_wsd_with_fixed_mean( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_long_double_wtss, "gsl_stats_long_double_wtss( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_wtss_m, "gsl_stats_long_double_wtss_m( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_long_double_wabsdev, "gsl_stats_long_double_wabsdev( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_wskew, "gsl_stats_long_double_wskew( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_wkurtosis, "gsl_stats_long_double_wkurtosis( w : array<double>, wstride : int, data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_wvariance_m, "gsl_stats_long_double_wvariance_m( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_long_double_wsd_m, "gsl_stats_long_double_wsd_m( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_long_double_wabsdev_m, "gsl_stats_long_double_wabsdev_m( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double )=>double" },
  { dao__gsl_stats_long_double_wskew_m_sd, "gsl_stats_long_double_wskew_m_sd( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double, wsd : double )=>double" },
  { dao__gsl_stats_long_double_wkurtosis_m_sd, "gsl_stats_long_double_wkurtosis_m_sd( w : array<double>, wstride : int, data : array<double>, stride : int, n : int, wmean : double, wsd : double )=>double" },
  { dao__gsl_stats_long_double_pvariance, "gsl_stats_long_double_pvariance( data1 : array<double>, stride1 : int, n1 : int, data2 : array<double>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_long_double_ttest, "gsl_stats_long_double_ttest( data1 : array<double>, stride1 : int, n1 : int, data2 : array<double>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_long_double_max, "gsl_stats_long_double_max( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_min, "gsl_stats_long_double_min( data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_minmax, "gsl_stats_long_double_minmax( min : double, max : double, data : array<double>, stride : int, n : int )" },
  { dao__gsl_stats_long_double_max_index, "gsl_stats_long_double_max_index( data : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_stats_long_double_min_index, "gsl_stats_long_double_min_index( data : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_stats_long_double_minmax_index, "gsl_stats_long_double_minmax_index( min_index : int, max_index : int, data : array<double>, stride : int, n : int )" },
  { dao__gsl_stats_long_double_median_from_sorted_data, "gsl_stats_long_double_median_from_sorted_data( sorted_data : array<double>, stride : int, n : int )=>double" },
  { dao__gsl_stats_long_double_quantile_from_sorted_data, "gsl_stats_long_double_quantile_from_sorted_data( sorted_data : array<double>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_short_mean, "gsl_stats_short_mean( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_variance, "gsl_stats_short_variance( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_sd, "gsl_stats_short_sd( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_variance_with_fixed_mean, "gsl_stats_short_variance_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_short_sd_with_fixed_mean, "gsl_stats_short_sd_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_short_tss, "gsl_stats_short_tss( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_tss_m, "gsl_stats_short_tss_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_short_absdev, "gsl_stats_short_absdev( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_skew, "gsl_stats_short_skew( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_kurtosis, "gsl_stats_short_kurtosis( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_lag1_autocorrelation, "gsl_stats_short_lag1_autocorrelation( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_covariance, "gsl_stats_short_covariance( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_short_correlation, "gsl_stats_short_correlation( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_short_variance_m, "gsl_stats_short_variance_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_short_sd_m, "gsl_stats_short_sd_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_short_absdev_m, "gsl_stats_short_absdev_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_short_skew_m_sd, "gsl_stats_short_skew_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_short_kurtosis_m_sd, "gsl_stats_short_kurtosis_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_short_lag1_autocorrelation_m, "gsl_stats_short_lag1_autocorrelation_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_short_covariance_m, "gsl_stats_short_covariance_m( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_short_pvariance, "gsl_stats_short_pvariance( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_short_ttest, "gsl_stats_short_ttest( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_short_max, "gsl_stats_short_max( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_short_min, "gsl_stats_short_min( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_short_minmax, "gsl_stats_short_minmax( min : int, max : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_short_max_index, "gsl_stats_short_max_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_short_min_index, "gsl_stats_short_min_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_short_minmax_index, "gsl_stats_short_minmax_index( min_index : int, max_index : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_short_median_from_sorted_data, "gsl_stats_short_median_from_sorted_data( sorted_data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_short_quantile_from_sorted_data, "gsl_stats_short_quantile_from_sorted_data( sorted_data : array<int>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_uchar_mean, "gsl_stats_uchar_mean( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_variance, "gsl_stats_uchar_variance( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_sd, "gsl_stats_uchar_sd( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_variance_with_fixed_mean, "gsl_stats_uchar_variance_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uchar_sd_with_fixed_mean, "gsl_stats_uchar_sd_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uchar_tss, "gsl_stats_uchar_tss( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_tss_m, "gsl_stats_uchar_tss_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uchar_absdev, "gsl_stats_uchar_absdev( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_skew, "gsl_stats_uchar_skew( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_kurtosis, "gsl_stats_uchar_kurtosis( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_lag1_autocorrelation, "gsl_stats_uchar_lag1_autocorrelation( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_covariance, "gsl_stats_uchar_covariance( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_uchar_correlation, "gsl_stats_uchar_correlation( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_uchar_variance_m, "gsl_stats_uchar_variance_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uchar_sd_m, "gsl_stats_uchar_sd_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uchar_absdev_m, "gsl_stats_uchar_absdev_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uchar_skew_m_sd, "gsl_stats_uchar_skew_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_uchar_kurtosis_m_sd, "gsl_stats_uchar_kurtosis_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_uchar_lag1_autocorrelation_m, "gsl_stats_uchar_lag1_autocorrelation_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uchar_covariance_m, "gsl_stats_uchar_covariance_m( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_uchar_pvariance, "gsl_stats_uchar_pvariance( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_uchar_ttest, "gsl_stats_uchar_ttest( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_uchar_max, "gsl_stats_uchar_max( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_uchar_min, "gsl_stats_uchar_min( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_uchar_minmax, "gsl_stats_uchar_minmax( min : string, max : string, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_uchar_max_index, "gsl_stats_uchar_max_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_uchar_min_index, "gsl_stats_uchar_min_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_uchar_minmax_index, "gsl_stats_uchar_minmax_index( min_index : int, max_index : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_uchar_median_from_sorted_data, "gsl_stats_uchar_median_from_sorted_data( sorted_data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uchar_quantile_from_sorted_data, "gsl_stats_uchar_quantile_from_sorted_data( sorted_data : array<int>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_uint_mean, "gsl_stats_uint_mean( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_variance, "gsl_stats_uint_variance( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_sd, "gsl_stats_uint_sd( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_variance_with_fixed_mean, "gsl_stats_uint_variance_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uint_sd_with_fixed_mean, "gsl_stats_uint_sd_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uint_tss, "gsl_stats_uint_tss( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_tss_m, "gsl_stats_uint_tss_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uint_absdev, "gsl_stats_uint_absdev( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_skew, "gsl_stats_uint_skew( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_kurtosis, "gsl_stats_uint_kurtosis( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_lag1_autocorrelation, "gsl_stats_uint_lag1_autocorrelation( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_covariance, "gsl_stats_uint_covariance( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_uint_correlation, "gsl_stats_uint_correlation( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_uint_variance_m, "gsl_stats_uint_variance_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uint_sd_m, "gsl_stats_uint_sd_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uint_absdev_m, "gsl_stats_uint_absdev_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uint_skew_m_sd, "gsl_stats_uint_skew_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_uint_kurtosis_m_sd, "gsl_stats_uint_kurtosis_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_uint_lag1_autocorrelation_m, "gsl_stats_uint_lag1_autocorrelation_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_uint_covariance_m, "gsl_stats_uint_covariance_m( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_uint_pvariance, "gsl_stats_uint_pvariance( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_uint_ttest, "gsl_stats_uint_ttest( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_uint_max, "gsl_stats_uint_max( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_uint_min, "gsl_stats_uint_min( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_uint_minmax, "gsl_stats_uint_minmax( min : int, max : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_uint_max_index, "gsl_stats_uint_max_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_uint_min_index, "gsl_stats_uint_min_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_uint_minmax_index, "gsl_stats_uint_minmax_index( min_index : int, max_index : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_uint_median_from_sorted_data, "gsl_stats_uint_median_from_sorted_data( sorted_data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_uint_quantile_from_sorted_data, "gsl_stats_uint_quantile_from_sorted_data( sorted_data : array<int>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_ulong_mean, "gsl_stats_ulong_mean( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_variance, "gsl_stats_ulong_variance( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_sd, "gsl_stats_ulong_sd( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_variance_with_fixed_mean, "gsl_stats_ulong_variance_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ulong_sd_with_fixed_mean, "gsl_stats_ulong_sd_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ulong_tss, "gsl_stats_ulong_tss( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_tss_m, "gsl_stats_ulong_tss_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ulong_absdev, "gsl_stats_ulong_absdev( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_skew, "gsl_stats_ulong_skew( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_kurtosis, "gsl_stats_ulong_kurtosis( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_lag1_autocorrelation, "gsl_stats_ulong_lag1_autocorrelation( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_covariance, "gsl_stats_ulong_covariance( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_ulong_correlation, "gsl_stats_ulong_correlation( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_ulong_variance_m, "gsl_stats_ulong_variance_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ulong_sd_m, "gsl_stats_ulong_sd_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ulong_absdev_m, "gsl_stats_ulong_absdev_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ulong_skew_m_sd, "gsl_stats_ulong_skew_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_ulong_kurtosis_m_sd, "gsl_stats_ulong_kurtosis_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_ulong_lag1_autocorrelation_m, "gsl_stats_ulong_lag1_autocorrelation_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ulong_covariance_m, "gsl_stats_ulong_covariance_m( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_ulong_pvariance, "gsl_stats_ulong_pvariance( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_ulong_ttest, "gsl_stats_ulong_ttest( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_ulong_max, "gsl_stats_ulong_max( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_ulong_min, "gsl_stats_ulong_min( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_ulong_minmax, "gsl_stats_ulong_minmax( min : int, max : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_ulong_max_index, "gsl_stats_ulong_max_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_ulong_min_index, "gsl_stats_ulong_min_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_ulong_minmax_index, "gsl_stats_ulong_minmax_index( min_index : int, max_index : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_ulong_median_from_sorted_data, "gsl_stats_ulong_median_from_sorted_data( sorted_data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ulong_quantile_from_sorted_data, "gsl_stats_ulong_quantile_from_sorted_data( sorted_data : array<int>, stride : int, n : int, f : double )=>double" },
  { dao__gsl_stats_ushort_mean, "gsl_stats_ushort_mean( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_variance, "gsl_stats_ushort_variance( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_sd, "gsl_stats_ushort_sd( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_variance_with_fixed_mean, "gsl_stats_ushort_variance_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ushort_sd_with_fixed_mean, "gsl_stats_ushort_sd_with_fixed_mean( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ushort_tss, "gsl_stats_ushort_tss( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_tss_m, "gsl_stats_ushort_tss_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ushort_absdev, "gsl_stats_ushort_absdev( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_skew, "gsl_stats_ushort_skew( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_kurtosis, "gsl_stats_ushort_kurtosis( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_lag1_autocorrelation, "gsl_stats_ushort_lag1_autocorrelation( data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_covariance, "gsl_stats_ushort_covariance( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_ushort_correlation, "gsl_stats_ushort_correlation( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int )=>double" },
  { dao__gsl_stats_ushort_variance_m, "gsl_stats_ushort_variance_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ushort_sd_m, "gsl_stats_ushort_sd_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ushort_absdev_m, "gsl_stats_ushort_absdev_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ushort_skew_m_sd, "gsl_stats_ushort_skew_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_ushort_kurtosis_m_sd, "gsl_stats_ushort_kurtosis_m_sd( data : array<int>, stride : int, n : int, mean : double, sd : double )=>double" },
  { dao__gsl_stats_ushort_lag1_autocorrelation_m, "gsl_stats_ushort_lag1_autocorrelation_m( data : array<int>, stride : int, n : int, mean : double )=>double" },
  { dao__gsl_stats_ushort_covariance_m, "gsl_stats_ushort_covariance_m( data1 : array<int>, stride1 : int, data2 : array<int>, stride2 : int, n : int, mean1 : double, mean2 : double )=>double" },
  { dao__gsl_stats_ushort_pvariance, "gsl_stats_ushort_pvariance( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_ushort_ttest, "gsl_stats_ushort_ttest( data1 : array<int>, stride1 : int, n1 : int, data2 : array<int>, stride2 : int, n2 : int )=>double" },
  { dao__gsl_stats_ushort_max, "gsl_stats_ushort_max( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_ushort_min, "gsl_stats_ushort_min( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_ushort_minmax, "gsl_stats_ushort_minmax( min : int, max : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_ushort_max_index, "gsl_stats_ushort_max_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_ushort_min_index, "gsl_stats_ushort_min_index( data : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_stats_ushort_minmax_index, "gsl_stats_ushort_minmax_index( min_index : int, max_index : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_stats_ushort_median_from_sorted_data, "gsl_stats_ushort_median_from_sorted_data( sorted_data : array<int>, stride : int, n : int )=>double" },
  { dao__gsl_stats_ushort_quantile_from_sorted_data, "gsl_stats_ushort_quantile_from_sorted_data( sorted_data : array<int>, stride : int, n : int, f : double )=>double" },
  { NULL, NULL }
};
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_mean = gsl_stats_char_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_mean );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_variance = gsl_stats_char_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_variance );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_sd = gsl_stats_char_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_sd );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_char_variance_with_fixed_mean = gsl_stats_char_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_variance_with_fixed_mean );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_char_sd_with_fixed_mean = gsl_stats_char_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_sd_with_fixed_mean );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_tss = gsl_stats_char_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_tss );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_char_tss_m = gsl_stats_char_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_tss_m );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_absdev = gsl_stats_char_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_absdev );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_skew = gsl_stats_char_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_skew );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_kurtosis = gsl_stats_char_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_kurtosis );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_lag1_autocorrelation = gsl_stats_char_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_lag1_autocorrelation );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data1= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  char* data2= (char*) DaoArray_ToByte( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_char_covariance = gsl_stats_char_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_covariance );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data1= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  char* data2= (char*) DaoArray_ToByte( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_char_correlation = gsl_stats_char_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_correlation );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_char_variance_m = gsl_stats_char_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_variance_m );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_char_sd_m = gsl_stats_char_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_sd_m );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_char_absdev_m = gsl_stats_char_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_absdev_m );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_char_skew_m_sd = gsl_stats_char_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_skew_m_sd );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_char_kurtosis_m_sd = gsl_stats_char_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_kurtosis_m_sd );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_char_lag1_autocorrelation_m = gsl_stats_char_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_lag1_autocorrelation_m );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data1= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  char* data2= (char*) DaoArray_ToByte( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_char_covariance_m = gsl_stats_char_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_covariance_m );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data1= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  char* data2= (char*) DaoArray_ToByte( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_char_pvariance = gsl_stats_char_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_pvariance );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data1= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  char* data2= (char*) DaoArray_ToByte( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_char_ttest = gsl_stats_char_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_ttest );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  char _gsl_stats_char_max = gsl_stats_char_max( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_char_max );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  char _gsl_stats_char_min = gsl_stats_char_min( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_char_min );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* min= (char*) DString_GetMBS( _p[0]->v.s );
  char* max= (char*) DString_GetMBS( _p[1]->v.s );
  char* data= (char*) DaoArray_ToByte( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_char_minmax( min, max, data, stride, n );
  DString_SetMBS( _p[0]->v.s, (char*) min );
  DString_SetMBS( _p[1]->v.s, (char*) max );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_char_max_index = gsl_stats_char_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_char_max_index );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_char_min_index = gsl_stats_char_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_char_min_index );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  char* data= (char*) DaoArray_ToByte( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_char_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* sorted_data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_char_median_from_sorted_data = gsl_stats_char_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_median_from_sorted_data );
}
/* gsl_statistics_char.h */
static void dao__gsl_stats_char_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* sorted_data= (char*) DaoArray_ToByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_char_quantile_from_sorted_data = gsl_stats_char_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_char_quantile_from_sorted_data );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_mean = gsl_stats_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_mean );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_variance = gsl_stats_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_variance );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_sd = gsl_stats_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_sd );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_variance_with_fixed_mean = gsl_stats_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_variance_with_fixed_mean );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_sd_with_fixed_mean = gsl_stats_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_sd_with_fixed_mean );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_tss = gsl_stats_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_tss );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_tss_m = gsl_stats_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_tss_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_absdev = gsl_stats_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_absdev );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_skew = gsl_stats_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_skew );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_kurtosis = gsl_stats_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_kurtosis );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_lag1_autocorrelation = gsl_stats_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_lag1_autocorrelation );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data1= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  double* data2= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_covariance = gsl_stats_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_covariance );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data1= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  double* data2= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_correlation = gsl_stats_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_correlation );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_variance_m = gsl_stats_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_variance_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_sd_m = gsl_stats_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_sd_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_absdev_m = gsl_stats_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_absdev_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_skew_m_sd = gsl_stats_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_skew_m_sd );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_kurtosis_m_sd = gsl_stats_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_kurtosis_m_sd );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_lag1_autocorrelation_m = gsl_stats_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_lag1_autocorrelation_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data1= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  double* data2= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_covariance_m = gsl_stats_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_covariance_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wmean( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_wmean = gsl_stats_wmean( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wmean );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_wvariance = gsl_stats_wvariance( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wvariance );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wsd( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_wsd = gsl_stats_wsd( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wsd );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wvariance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean= (double) _p[5]->v.d;

  double _gsl_stats_wvariance_with_fixed_mean = gsl_stats_wvariance_with_fixed_mean( w, wstride, data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wvariance_with_fixed_mean );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wsd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean= (double) _p[5]->v.d;

  double _gsl_stats_wsd_with_fixed_mean = gsl_stats_wsd_with_fixed_mean( w, wstride, data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wsd_with_fixed_mean );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wtss( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_wtss = gsl_stats_wtss( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wtss );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wtss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_wtss_m = gsl_stats_wtss_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wtss_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wabsdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_wabsdev = gsl_stats_wabsdev( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wabsdev );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wskew( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_wskew = gsl_stats_wskew( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wskew );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wkurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_wkurtosis = gsl_stats_wkurtosis( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wkurtosis );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wvariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_wvariance_m = gsl_stats_wvariance_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wvariance_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wsd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_wsd_m = gsl_stats_wsd_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wsd_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wabsdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_wabsdev_m = gsl_stats_wabsdev_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wabsdev_m );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wskew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;
  double wsd= (double) _p[6]->v.d;

  double _gsl_stats_wskew_m_sd = gsl_stats_wskew_m_sd( w, wstride, data, stride, n, wmean, wsd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wskew_m_sd );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_wkurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* w= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;
  double wsd= (double) _p[6]->v.d;

  double _gsl_stats_wkurtosis_m_sd = gsl_stats_wkurtosis_m_sd( w, wstride, data, stride, n, wmean, wsd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_wkurtosis_m_sd );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data1= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  double* data2= (double*) DaoArray_ToDouble( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_pvariance = gsl_stats_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_pvariance );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data1= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  double* data2= (double*) DaoArray_ToDouble( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_ttest = gsl_stats_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ttest );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_max = gsl_stats_max( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_max );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_min = gsl_stats_min( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_min );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  double min= (double) _p[0]->v.d;
  double max= (double) _p[1]->v.d;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_minmax( & min, & max, data, stride, n );
  _p[0]->v.d = (double) min;
  _p[1]->v.d = (double) max;
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_max_index = gsl_stats_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_max_index );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_min_index = gsl_stats_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_min_index );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* sorted_data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_median_from_sorted_data = gsl_stats_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_median_from_sorted_data );
}
/* gsl_statistics_double.h */
static void dao__gsl_stats_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* sorted_data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_quantile_from_sorted_data = gsl_stats_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_quantile_from_sorted_data );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_mean = gsl_stats_float_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_mean );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_variance = gsl_stats_float_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_variance );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_sd = gsl_stats_float_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_sd );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_float_variance_with_fixed_mean = gsl_stats_float_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_variance_with_fixed_mean );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_float_sd_with_fixed_mean = gsl_stats_float_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_sd_with_fixed_mean );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_tss = gsl_stats_float_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_tss );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_float_tss_m = gsl_stats_float_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_tss_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_absdev = gsl_stats_float_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_absdev );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_skew = gsl_stats_float_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_skew );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_kurtosis = gsl_stats_float_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_kurtosis );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_lag1_autocorrelation = gsl_stats_float_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_lag1_autocorrelation );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data1= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  float* data2= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_covariance = gsl_stats_float_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_covariance );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data1= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  float* data2= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_correlation = gsl_stats_float_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_correlation );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_float_variance_m = gsl_stats_float_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_variance_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_float_sd_m = gsl_stats_float_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_sd_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_float_absdev_m = gsl_stats_float_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_absdev_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_float_skew_m_sd = gsl_stats_float_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_skew_m_sd );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_float_kurtosis_m_sd = gsl_stats_float_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_kurtosis_m_sd );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_float_lag1_autocorrelation_m = gsl_stats_float_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_lag1_autocorrelation_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data1= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  float* data2= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_float_covariance_m = gsl_stats_float_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_covariance_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wmean( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_wmean = gsl_stats_float_wmean( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wmean );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_wvariance = gsl_stats_float_wvariance( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wvariance );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wsd( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_wsd = gsl_stats_float_wsd( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wsd );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wvariance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean= (double) _p[5]->v.d;

  double _gsl_stats_float_wvariance_with_fixed_mean = gsl_stats_float_wvariance_with_fixed_mean( w, wstride, data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wvariance_with_fixed_mean );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wsd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean= (double) _p[5]->v.d;

  double _gsl_stats_float_wsd_with_fixed_mean = gsl_stats_float_wsd_with_fixed_mean( w, wstride, data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wsd_with_fixed_mean );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wtss( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_wtss = gsl_stats_float_wtss( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wtss );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wtss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_float_wtss_m = gsl_stats_float_wtss_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wtss_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wabsdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_wabsdev = gsl_stats_float_wabsdev( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wabsdev );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wskew( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_wskew = gsl_stats_float_wskew( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wskew );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wkurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_float_wkurtosis = gsl_stats_float_wkurtosis( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wkurtosis );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wvariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_float_wvariance_m = gsl_stats_float_wvariance_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wvariance_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wsd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_float_wsd_m = gsl_stats_float_wsd_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wsd_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wabsdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_float_wabsdev_m = gsl_stats_float_wabsdev_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wabsdev_m );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wskew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;
  double wsd= (double) _p[6]->v.d;

  double _gsl_stats_float_wskew_m_sd = gsl_stats_float_wskew_m_sd( w, wstride, data, stride, n, wmean, wsd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wskew_m_sd );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_wkurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* w= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;
  double wsd= (double) _p[6]->v.d;

  double _gsl_stats_float_wkurtosis_m_sd = gsl_stats_float_wkurtosis_m_sd( w, wstride, data, stride, n, wmean, wsd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_wkurtosis_m_sd );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data1= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  float* data2= (float*) DaoArray_ToFloat( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_float_pvariance = gsl_stats_float_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_pvariance );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data1= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  float* data2= (float*) DaoArray_ToFloat( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_float_ttest = gsl_stats_float_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_ttest );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  float _gsl_stats_float_max = gsl_stats_float_max( data, stride, n );
  DaoContext_PutFloat( _ctx, (float) _gsl_stats_float_max );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  float _gsl_stats_float_min = gsl_stats_float_min( data, stride, n );
  DaoContext_PutFloat( _ctx, (float) _gsl_stats_float_min );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  float min= (float) _p[0]->v.f;
  float max= (float) _p[1]->v.f;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_float_minmax( & min, & max, data, stride, n );
  _p[0]->v.f = (float) min;
  _p[1]->v.f = (float) max;
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_float_max_index = gsl_stats_float_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_float_max_index );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_float_min_index = gsl_stats_float_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_float_min_index );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_float_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* sorted_data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_float_median_from_sorted_data = gsl_stats_float_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_median_from_sorted_data );
}
/* gsl_statistics_float.h */
static void dao__gsl_stats_float_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* sorted_data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_float_quantile_from_sorted_data = gsl_stats_float_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_float_quantile_from_sorted_data );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_mean = gsl_stats_int_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_mean );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_variance = gsl_stats_int_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_variance );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_sd = gsl_stats_int_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_sd );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_int_variance_with_fixed_mean = gsl_stats_int_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_variance_with_fixed_mean );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_int_sd_with_fixed_mean = gsl_stats_int_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_sd_with_fixed_mean );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_tss = gsl_stats_int_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_tss );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_int_tss_m = gsl_stats_int_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_tss_m );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_absdev = gsl_stats_int_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_absdev );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_skew = gsl_stats_int_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_skew );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_kurtosis = gsl_stats_int_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_kurtosis );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_lag1_autocorrelation = gsl_stats_int_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_lag1_autocorrelation );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data1= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  int* data2= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_int_covariance = gsl_stats_int_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_covariance );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data1= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  int* data2= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_int_correlation = gsl_stats_int_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_correlation );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_int_variance_m = gsl_stats_int_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_variance_m );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_int_sd_m = gsl_stats_int_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_sd_m );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_int_absdev_m = gsl_stats_int_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_absdev_m );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_int_skew_m_sd = gsl_stats_int_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_skew_m_sd );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_int_kurtosis_m_sd = gsl_stats_int_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_kurtosis_m_sd );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_int_lag1_autocorrelation_m = gsl_stats_int_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_lag1_autocorrelation_m );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data1= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  int* data2= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_int_covariance_m = gsl_stats_int_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_covariance_m );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data1= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  int* data2= (int*) DaoArray_ToInt( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_int_pvariance = gsl_stats_int_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_pvariance );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data1= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  int* data2= (int*) DaoArray_ToInt( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_int_ttest = gsl_stats_int_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_ttest );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  int _gsl_stats_int_max = gsl_stats_int_max( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_int_max );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  int _gsl_stats_int_min = gsl_stats_int_min( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_int_min );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  int min= (int) _p[0]->v.i;
  int max= (int) _p[1]->v.i;
  int* data= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_int_minmax( & min, & max, data, stride, n );
  _p[0]->v.i = (int) min;
  _p[1]->v.i = (int) max;
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_int_max_index = gsl_stats_int_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_int_max_index );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_int_min_index = gsl_stats_int_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_int_min_index );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  int* data= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_int_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* sorted_data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_int_median_from_sorted_data = gsl_stats_int_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_median_from_sorted_data );
}
/* gsl_statistics_int.h */
static void dao__gsl_stats_int_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* sorted_data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_int_quantile_from_sorted_data = gsl_stats_int_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_int_quantile_from_sorted_data );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_mean = gsl_stats_long_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_mean );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_variance = gsl_stats_long_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_variance );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_sd = gsl_stats_long_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_sd );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_variance_with_fixed_mean = gsl_stats_long_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_variance_with_fixed_mean );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_sd_with_fixed_mean = gsl_stats_long_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_sd_with_fixed_mean );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_tss = gsl_stats_long_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_tss );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_tss_m = gsl_stats_long_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_tss_m );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_absdev = gsl_stats_long_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_absdev );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_skew = gsl_stats_long_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_skew );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_kurtosis = gsl_stats_long_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_kurtosis );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_lag1_autocorrelation = gsl_stats_long_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_lag1_autocorrelation );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data1= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  long* data2= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_covariance = gsl_stats_long_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_covariance );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data1= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  long* data2= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_correlation = gsl_stats_long_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_correlation );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_variance_m = gsl_stats_long_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_variance_m );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_sd_m = gsl_stats_long_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_sd_m );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_absdev_m = gsl_stats_long_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_absdev_m );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_long_skew_m_sd = gsl_stats_long_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_skew_m_sd );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_long_kurtosis_m_sd = gsl_stats_long_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_kurtosis_m_sd );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_lag1_autocorrelation_m = gsl_stats_long_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_lag1_autocorrelation_m );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data1= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  long* data2= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_long_covariance_m = gsl_stats_long_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_covariance_m );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data1= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  long* data2= (long*) DaoArray_ToInt( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_long_pvariance = gsl_stats_long_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_pvariance );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data1= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  long* data2= (long*) DaoArray_ToInt( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_long_ttest = gsl_stats_long_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_ttest );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  long _gsl_stats_long_max = gsl_stats_long_max( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_long_max );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  long _gsl_stats_long_min = gsl_stats_long_min( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_long_min );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  long min= (long) _p[0]->v.i;
  long max= (long) _p[1]->v.i;
  long* data= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_long_minmax( & min, & max, data, stride, n );
  _p[0]->v.i = (int) min;
  _p[1]->v.i = (int) max;
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_long_max_index = gsl_stats_long_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_long_max_index );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_long_min_index = gsl_stats_long_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_long_min_index );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  long* data= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_long_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* sorted_data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_median_from_sorted_data = gsl_stats_long_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_median_from_sorted_data );
}
/* gsl_statistics_long.h */
static void dao__gsl_stats_long_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* sorted_data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_long_quantile_from_sorted_data = gsl_stats_long_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_quantile_from_sorted_data );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_mean = gsl_stats_long_double_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_mean );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_variance = gsl_stats_long_double_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_variance );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_sd = gsl_stats_long_double_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_sd );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_double_variance_with_fixed_mean = gsl_stats_long_double_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_variance_with_fixed_mean );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_double_sd_with_fixed_mean = gsl_stats_long_double_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_sd_with_fixed_mean );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_tss = gsl_stats_long_double_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_tss );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_double_tss_m = gsl_stats_long_double_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_tss_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_absdev = gsl_stats_long_double_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_absdev );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_skew = gsl_stats_long_double_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_skew );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_kurtosis = gsl_stats_long_double_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_kurtosis );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_lag1_autocorrelation = gsl_stats_long_double_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_lag1_autocorrelation );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data1= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  long double* data2= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_covariance = gsl_stats_long_double_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_covariance );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data1= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  long double* data2= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_correlation = gsl_stats_long_double_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_correlation );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_double_variance_m = gsl_stats_long_double_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_variance_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_double_sd_m = gsl_stats_long_double_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_sd_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_double_absdev_m = gsl_stats_long_double_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_absdev_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_long_double_skew_m_sd = gsl_stats_long_double_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_skew_m_sd );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_long_double_kurtosis_m_sd = gsl_stats_long_double_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_kurtosis_m_sd );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_long_double_lag1_autocorrelation_m = gsl_stats_long_double_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_lag1_autocorrelation_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data1= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  long double* data2= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_long_double_covariance_m = gsl_stats_long_double_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_covariance_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wmean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_wmean = gsl_stats_long_double_wmean( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wmean );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_wvariance = gsl_stats_long_double_wvariance( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wvariance );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wsd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_wsd = gsl_stats_long_double_wsd( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wsd );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wvariance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean= (double) _p[5]->v.d;

  double _gsl_stats_long_double_wvariance_with_fixed_mean = gsl_stats_long_double_wvariance_with_fixed_mean( w, wstride, data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wvariance_with_fixed_mean );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wsd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean= (double) _p[5]->v.d;

  double _gsl_stats_long_double_wsd_with_fixed_mean = gsl_stats_long_double_wsd_with_fixed_mean( w, wstride, data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wsd_with_fixed_mean );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wtss( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_wtss = gsl_stats_long_double_wtss( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wtss );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wtss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_long_double_wtss_m = gsl_stats_long_double_wtss_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wtss_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wabsdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_wabsdev = gsl_stats_long_double_wabsdev( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wabsdev );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wskew( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_wskew = gsl_stats_long_double_wskew( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wskew );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wkurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_long_double_wkurtosis = gsl_stats_long_double_wkurtosis( w, wstride, data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wkurtosis );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wvariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_long_double_wvariance_m = gsl_stats_long_double_wvariance_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wvariance_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wsd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_long_double_wsd_m = gsl_stats_long_double_wsd_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wsd_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wabsdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;

  double _gsl_stats_long_double_wabsdev_m = gsl_stats_long_double_wabsdev_m( w, wstride, data, stride, n, wmean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wabsdev_m );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wskew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;
  double wsd= (double) _p[6]->v.d;

  double _gsl_stats_long_double_wskew_m_sd = gsl_stats_long_double_wskew_m_sd( w, wstride, data, stride, n, wmean, wsd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wskew_m_sd );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_wkurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* w= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t wstride= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double wmean= (double) _p[5]->v.d;
  double wsd= (double) _p[6]->v.d;

  double _gsl_stats_long_double_wkurtosis_m_sd = gsl_stats_long_double_wkurtosis_m_sd( w, wstride, data, stride, n, wmean, wsd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_wkurtosis_m_sd );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data1= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  long double* data2= (long double*) DaoArray_ToDouble( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_long_double_pvariance = gsl_stats_long_double_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_pvariance );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data1= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  long double* data2= (long double*) DaoArray_ToDouble( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_long_double_ttest = gsl_stats_long_double_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_ttest );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  long double _gsl_stats_long_double_max = gsl_stats_long_double_max( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_max );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  long double _gsl_stats_long_double_min = gsl_stats_long_double_min( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_min );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double min= (long double) _p[0]->v.d;
  long double max= (long double) _p[1]->v.d;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_long_double_minmax( & min, & max, data, stride, n );
  _p[0]->v.d = (double) min;
  _p[1]->v.d = (double) max;
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_long_double_max_index = gsl_stats_long_double_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_long_double_max_index );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_long_double_min_index = gsl_stats_long_double_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_long_double_min_index );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_long_double_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* sorted_data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_long_double_median_from_sorted_data = gsl_stats_long_double_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_median_from_sorted_data );
}
/* gsl_statistics_long_double.h */
static void dao__gsl_stats_long_double_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* sorted_data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_long_double_quantile_from_sorted_data = gsl_stats_long_double_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_long_double_quantile_from_sorted_data );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_mean = gsl_stats_short_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_mean );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_variance = gsl_stats_short_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_variance );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_sd = gsl_stats_short_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_sd );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_short_variance_with_fixed_mean = gsl_stats_short_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_variance_with_fixed_mean );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_short_sd_with_fixed_mean = gsl_stats_short_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_sd_with_fixed_mean );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_tss = gsl_stats_short_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_tss );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_short_tss_m = gsl_stats_short_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_tss_m );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_absdev = gsl_stats_short_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_absdev );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_skew = gsl_stats_short_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_skew );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_kurtosis = gsl_stats_short_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_kurtosis );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_lag1_autocorrelation = gsl_stats_short_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_lag1_autocorrelation );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data1= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  short* data2= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_short_covariance = gsl_stats_short_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_covariance );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data1= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  short* data2= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_short_correlation = gsl_stats_short_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_correlation );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_short_variance_m = gsl_stats_short_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_variance_m );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_short_sd_m = gsl_stats_short_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_sd_m );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_short_absdev_m = gsl_stats_short_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_absdev_m );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_short_skew_m_sd = gsl_stats_short_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_skew_m_sd );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_short_kurtosis_m_sd = gsl_stats_short_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_kurtosis_m_sd );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_short_lag1_autocorrelation_m = gsl_stats_short_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_lag1_autocorrelation_m );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data1= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  short* data2= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_short_covariance_m = gsl_stats_short_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_covariance_m );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data1= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  short* data2= (short*) DaoArray_ToShort( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_short_pvariance = gsl_stats_short_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_pvariance );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data1= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  short* data2= (short*) DaoArray_ToShort( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_short_ttest = gsl_stats_short_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_ttest );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  short _gsl_stats_short_max = gsl_stats_short_max( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_short_max );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  short _gsl_stats_short_min = gsl_stats_short_min( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_short_min );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  short min= (short) _p[0]->v.i;
  short max= (short) _p[1]->v.i;
  short* data= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_short_minmax( & min, & max, data, stride, n );
  _p[0]->v.i = (int) min;
  _p[1]->v.i = (int) max;
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_short_max_index = gsl_stats_short_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_short_max_index );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_short_min_index = gsl_stats_short_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_short_min_index );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  short* data= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_short_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* sorted_data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_short_median_from_sorted_data = gsl_stats_short_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_median_from_sorted_data );
}
/* gsl_statistics_short.h */
static void dao__gsl_stats_short_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* sorted_data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_short_quantile_from_sorted_data = gsl_stats_short_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_short_quantile_from_sorted_data );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_mean = gsl_stats_uchar_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_mean );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_variance = gsl_stats_uchar_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_variance );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_sd = gsl_stats_uchar_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_sd );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uchar_variance_with_fixed_mean = gsl_stats_uchar_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_variance_with_fixed_mean );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uchar_sd_with_fixed_mean = gsl_stats_uchar_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_sd_with_fixed_mean );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_tss = gsl_stats_uchar_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_tss );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uchar_tss_m = gsl_stats_uchar_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_tss_m );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_absdev = gsl_stats_uchar_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_absdev );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_skew = gsl_stats_uchar_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_skew );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_kurtosis = gsl_stats_uchar_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_kurtosis );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_lag1_autocorrelation = gsl_stats_uchar_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_lag1_autocorrelation );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data1= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned char* data2= (unsigned char*) DaoArray_ToUByte( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_uchar_covariance = gsl_stats_uchar_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_covariance );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data1= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned char* data2= (unsigned char*) DaoArray_ToUByte( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_uchar_correlation = gsl_stats_uchar_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_correlation );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uchar_variance_m = gsl_stats_uchar_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_variance_m );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uchar_sd_m = gsl_stats_uchar_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_sd_m );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uchar_absdev_m = gsl_stats_uchar_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_absdev_m );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_uchar_skew_m_sd = gsl_stats_uchar_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_skew_m_sd );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_uchar_kurtosis_m_sd = gsl_stats_uchar_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_kurtosis_m_sd );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uchar_lag1_autocorrelation_m = gsl_stats_uchar_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_lag1_autocorrelation_m );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data1= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned char* data2= (unsigned char*) DaoArray_ToUByte( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_uchar_covariance_m = gsl_stats_uchar_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_covariance_m );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data1= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  unsigned char* data2= (unsigned char*) DaoArray_ToUByte( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_uchar_pvariance = gsl_stats_uchar_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_pvariance );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data1= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  unsigned char* data2= (unsigned char*) DaoArray_ToUByte( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_uchar_ttest = gsl_stats_uchar_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_ttest );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  unsigned char _gsl_stats_uchar_max = gsl_stats_uchar_max( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_uchar_max );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  unsigned char _gsl_stats_uchar_min = gsl_stats_uchar_min( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_uchar_min );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* min= (unsigned char*) DString_GetMBS( _p[0]->v.s );
  unsigned char* max= (unsigned char*) DString_GetMBS( _p[1]->v.s );
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_uchar_minmax( min, max, data, stride, n );
  DString_SetMBS( _p[0]->v.s, (char*) min );
  DString_SetMBS( _p[1]->v.s, (char*) max );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_uchar_max_index = gsl_stats_uchar_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_uchar_max_index );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_uchar_min_index = gsl_stats_uchar_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_uchar_min_index );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  unsigned char* data= (unsigned char*) DaoArray_ToUByte( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_uchar_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* sorted_data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uchar_median_from_sorted_data = gsl_stats_uchar_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_median_from_sorted_data );
}
/* gsl_statistics_uchar.h */
static void dao__gsl_stats_uchar_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* sorted_data= (unsigned char*) DaoArray_ToUByte( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_uchar_quantile_from_sorted_data = gsl_stats_uchar_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uchar_quantile_from_sorted_data );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_mean = gsl_stats_uint_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_mean );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_variance = gsl_stats_uint_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_variance );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_sd = gsl_stats_uint_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_sd );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uint_variance_with_fixed_mean = gsl_stats_uint_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_variance_with_fixed_mean );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uint_sd_with_fixed_mean = gsl_stats_uint_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_sd_with_fixed_mean );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_tss = gsl_stats_uint_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_tss );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uint_tss_m = gsl_stats_uint_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_tss_m );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_absdev = gsl_stats_uint_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_absdev );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_skew = gsl_stats_uint_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_skew );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_kurtosis = gsl_stats_uint_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_kurtosis );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_lag1_autocorrelation = gsl_stats_uint_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_lag1_autocorrelation );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data1= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned int* data2= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_uint_covariance = gsl_stats_uint_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_covariance );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data1= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned int* data2= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_uint_correlation = gsl_stats_uint_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_correlation );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uint_variance_m = gsl_stats_uint_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_variance_m );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uint_sd_m = gsl_stats_uint_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_sd_m );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uint_absdev_m = gsl_stats_uint_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_absdev_m );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_uint_skew_m_sd = gsl_stats_uint_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_skew_m_sd );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_uint_kurtosis_m_sd = gsl_stats_uint_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_kurtosis_m_sd );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_uint_lag1_autocorrelation_m = gsl_stats_uint_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_lag1_autocorrelation_m );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data1= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned int* data2= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_uint_covariance_m = gsl_stats_uint_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_covariance_m );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data1= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  unsigned int* data2= (unsigned int*) DaoArray_ToUInt( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_uint_pvariance = gsl_stats_uint_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_pvariance );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data1= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  unsigned int* data2= (unsigned int*) DaoArray_ToUInt( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_uint_ttest = gsl_stats_uint_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_ttest );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  unsigned int _gsl_stats_uint_max = gsl_stats_uint_max( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_uint_max );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  unsigned int _gsl_stats_uint_min = gsl_stats_uint_min( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_uint_min );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int min= (unsigned int) _p[0]->v.i;
  unsigned int max= (unsigned int) _p[1]->v.i;
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_uint_minmax( & min, & max, data, stride, n );
  _p[0]->v.i = (int) min;
  _p[1]->v.i = (int) max;
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_uint_max_index = gsl_stats_uint_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_uint_max_index );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_uint_min_index = gsl_stats_uint_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_uint_min_index );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_uint_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* sorted_data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_uint_median_from_sorted_data = gsl_stats_uint_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_median_from_sorted_data );
}
/* gsl_statistics_uint.h */
static void dao__gsl_stats_uint_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* sorted_data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_uint_quantile_from_sorted_data = gsl_stats_uint_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_uint_quantile_from_sorted_data );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_mean = gsl_stats_ulong_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_mean );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_variance = gsl_stats_ulong_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_variance );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_sd = gsl_stats_ulong_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_sd );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ulong_variance_with_fixed_mean = gsl_stats_ulong_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_variance_with_fixed_mean );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ulong_sd_with_fixed_mean = gsl_stats_ulong_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_sd_with_fixed_mean );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_tss = gsl_stats_ulong_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_tss );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ulong_tss_m = gsl_stats_ulong_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_tss_m );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_absdev = gsl_stats_ulong_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_absdev );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_skew = gsl_stats_ulong_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_skew );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_kurtosis = gsl_stats_ulong_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_kurtosis );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_lag1_autocorrelation = gsl_stats_ulong_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_lag1_autocorrelation );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data1= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned long* data2= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_ulong_covariance = gsl_stats_ulong_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_covariance );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data1= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned long* data2= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_ulong_correlation = gsl_stats_ulong_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_correlation );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ulong_variance_m = gsl_stats_ulong_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_variance_m );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ulong_sd_m = gsl_stats_ulong_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_sd_m );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ulong_absdev_m = gsl_stats_ulong_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_absdev_m );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_ulong_skew_m_sd = gsl_stats_ulong_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_skew_m_sd );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_ulong_kurtosis_m_sd = gsl_stats_ulong_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_kurtosis_m_sd );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ulong_lag1_autocorrelation_m = gsl_stats_ulong_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_lag1_autocorrelation_m );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data1= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned long* data2= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_ulong_covariance_m = gsl_stats_ulong_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_covariance_m );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data1= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  unsigned long* data2= (unsigned long*) DaoArray_ToUInt( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_ulong_pvariance = gsl_stats_ulong_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_pvariance );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data1= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  unsigned long* data2= (unsigned long*) DaoArray_ToUInt( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_ulong_ttest = gsl_stats_ulong_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_ttest );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  unsigned long _gsl_stats_ulong_max = gsl_stats_ulong_max( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_ulong_max );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  unsigned long _gsl_stats_ulong_min = gsl_stats_ulong_min( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_ulong_min );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long min= (unsigned long) _p[0]->v.i;
  unsigned long max= (unsigned long) _p[1]->v.i;
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_ulong_minmax( & min, & max, data, stride, n );
  _p[0]->v.i = (int) min;
  _p[1]->v.i = (int) max;
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_ulong_max_index = gsl_stats_ulong_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_ulong_max_index );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_ulong_min_index = gsl_stats_ulong_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_ulong_min_index );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_ulong_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* sorted_data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ulong_median_from_sorted_data = gsl_stats_ulong_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_median_from_sorted_data );
}
/* gsl_statistics_ulong.h */
static void dao__gsl_stats_ulong_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* sorted_data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_ulong_quantile_from_sorted_data = gsl_stats_ulong_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ulong_quantile_from_sorted_data );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_mean = gsl_stats_ushort_mean( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_mean );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_variance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_variance = gsl_stats_ushort_variance( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_variance );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_sd = gsl_stats_ushort_sd( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_sd );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_variance_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ushort_variance_with_fixed_mean = gsl_stats_ushort_variance_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_variance_with_fixed_mean );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_sd_with_fixed_mean( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ushort_sd_with_fixed_mean = gsl_stats_ushort_sd_with_fixed_mean( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_sd_with_fixed_mean );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_tss( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_tss = gsl_stats_ushort_tss( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_tss );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_tss_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ushort_tss_m = gsl_stats_ushort_tss_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_tss_m );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_absdev( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_absdev = gsl_stats_ushort_absdev( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_absdev );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_skew( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_skew = gsl_stats_ushort_skew( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_skew );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_kurtosis( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_kurtosis = gsl_stats_ushort_kurtosis( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_kurtosis );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_lag1_autocorrelation( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_lag1_autocorrelation = gsl_stats_ushort_lag1_autocorrelation( data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_lag1_autocorrelation );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_covariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data1= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned short* data2= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_ushort_covariance = gsl_stats_ushort_covariance( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_covariance );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_correlation( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data1= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned short* data2= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  double _gsl_stats_ushort_correlation = gsl_stats_ushort_correlation( data1, stride1, data2, stride2, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_correlation );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_variance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ushort_variance_m = gsl_stats_ushort_variance_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_variance_m );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_sd_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ushort_sd_m = gsl_stats_ushort_sd_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_sd_m );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_absdev_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ushort_absdev_m = gsl_stats_ushort_absdev_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_absdev_m );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_skew_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_ushort_skew_m_sd = gsl_stats_ushort_skew_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_skew_m_sd );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_kurtosis_m_sd( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;
  double sd= (double) _p[4]->v.d;

  double _gsl_stats_ushort_kurtosis_m_sd = gsl_stats_ushort_kurtosis_m_sd( data, stride, n, mean, sd );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_kurtosis_m_sd );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_lag1_autocorrelation_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double mean= (double) _p[3]->v.d;

  double _gsl_stats_ushort_lag1_autocorrelation_m = gsl_stats_ushort_lag1_autocorrelation_m( data, stride, n, mean );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_lag1_autocorrelation_m );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_covariance_m( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data1= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  unsigned short* data2= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride2= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;
  double mean1= (double) _p[5]->v.d;
  double mean2= (double) _p[6]->v.d;

  double _gsl_stats_ushort_covariance_m = gsl_stats_ushort_covariance_m( data1, stride1, data2, stride2, n, mean1, mean2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_covariance_m );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_pvariance( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data1= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  unsigned short* data2= (unsigned short*) DaoArray_ToUShort( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_ushort_pvariance = gsl_stats_ushort_pvariance( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_pvariance );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_ttest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data1= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride1= (size_t) _p[1]->v.i;
  size_t n1= (size_t) _p[2]->v.i;
  unsigned short* data2= (unsigned short*) DaoArray_ToUShort( _p[3]->v.array );
  size_t stride2= (size_t) _p[4]->v.i;
  size_t n2= (size_t) _p[5]->v.i;

  double _gsl_stats_ushort_ttest = gsl_stats_ushort_ttest( data1, stride1, n1, data2, stride2, n2 );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_ttest );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_max( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  unsigned short _gsl_stats_ushort_max = gsl_stats_ushort_max( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_ushort_max );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_min( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  unsigned short _gsl_stats_ushort_min = gsl_stats_ushort_min( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_ushort_min );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_minmax( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short min= (unsigned short) _p[0]->v.i;
  unsigned short max= (unsigned short) _p[1]->v.i;
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_ushort_minmax( & min, & max, data, stride, n );
  _p[0]->v.i = (int) min;
  _p[1]->v.i = (int) max;
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_max_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_ushort_max_index = gsl_stats_ushort_max_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_ushort_max_index );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_min_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  size_t _gsl_stats_ushort_min_index = gsl_stats_ushort_min_index( data, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_stats_ushort_min_index );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_minmax_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t min_index= (size_t) _p[0]->v.i;
  size_t max_index= (size_t) _p[1]->v.i;
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  gsl_stats_ushort_minmax_index( & min_index, & max_index, data, stride, n );
  _p[0]->v.i = (int) min_index;
  _p[1]->v.i = (int) max_index;
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_median_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* sorted_data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  double _gsl_stats_ushort_median_from_sorted_data = gsl_stats_ushort_median_from_sorted_data( sorted_data, stride, n );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_median_from_sorted_data );
}
/* gsl_statistics_ushort.h */
static void dao__gsl_stats_ushort_quantile_from_sorted_data( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* sorted_data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;
  double f= (double) _p[3]->v.d;

  double _gsl_stats_ushort_quantile_from_sorted_data = gsl_stats_ushort_quantile_from_sorted_data( sorted_data, stride, n, f );
  DaoContext_PutDouble( _ctx, (double) _gsl_stats_ushort_quantile_from_sorted_data );
}

int DaoOnLoad( DaoVmSpace *vms, DaoNameSpace *ns )
{
  DaoTypeBase *typers[106];
  const char *aliases[1];
  __daoVmSpace = vms;
  typers[0] = dao__gsl_matrix_char_const_view_Typer,
  typers[1] = dao__gsl_matrix_char_view_Typer,
  typers[2] = dao__gsl_matrix_complex_const_view_Typer,
  typers[3] = dao__gsl_matrix_complex_float_const_view_Typer,
  typers[4] = dao__gsl_matrix_complex_float_view_Typer,
  typers[5] = dao__gsl_matrix_complex_long_double_const_view_Typer,
  typers[6] = dao__gsl_matrix_complex_long_double_view_Typer,
  typers[7] = dao__gsl_matrix_complex_view_Typer,
  typers[8] = dao__gsl_matrix_const_view_Typer,
  typers[9] = dao__gsl_matrix_float_const_view_Typer,
  typers[10] = dao__gsl_matrix_float_view_Typer,
  typers[11] = dao__gsl_matrix_int_const_view_Typer,
  typers[12] = dao__gsl_matrix_int_view_Typer,
  typers[13] = dao__gsl_matrix_long_const_view_Typer,
  typers[14] = dao__gsl_matrix_long_double_const_view_Typer,
  typers[15] = dao__gsl_matrix_long_double_view_Typer,
  typers[16] = dao__gsl_matrix_long_view_Typer,
  typers[17] = dao__gsl_matrix_short_const_view_Typer,
  typers[18] = dao__gsl_matrix_short_view_Typer,
  typers[19] = dao__gsl_matrix_uchar_const_view_Typer,
  typers[20] = dao__gsl_matrix_uchar_view_Typer,
  typers[21] = dao__gsl_matrix_uint_const_view_Typer,
  typers[22] = dao__gsl_matrix_uint_view_Typer,
  typers[23] = dao__gsl_matrix_ulong_const_view_Typer,
  typers[24] = dao__gsl_matrix_ulong_view_Typer,
  typers[25] = dao__gsl_matrix_ushort_const_view_Typer,
  typers[26] = dao__gsl_matrix_ushort_view_Typer,
  typers[27] = dao__gsl_matrix_view_Typer,
  typers[28] = dao__gsl_vector_char_const_view_Typer,
  typers[29] = dao__gsl_vector_char_view_Typer,
  typers[30] = dao__gsl_vector_complex_const_view_Typer,
  typers[31] = dao__gsl_vector_complex_float_const_view_Typer,
  typers[32] = dao__gsl_vector_complex_float_view_Typer,
  typers[33] = dao__gsl_vector_complex_long_double_const_view_Typer,
  typers[34] = dao__gsl_vector_complex_long_double_view_Typer,
  typers[35] = dao__gsl_vector_complex_view_Typer,
  typers[36] = dao__gsl_vector_const_view_Typer,
  typers[37] = dao__gsl_vector_float_const_view_Typer,
  typers[38] = dao__gsl_vector_float_view_Typer,
  typers[39] = dao__gsl_vector_int_const_view_Typer,
  typers[40] = dao__gsl_vector_int_view_Typer,
  typers[41] = dao__gsl_vector_long_const_view_Typer,
  typers[42] = dao__gsl_vector_long_double_const_view_Typer,
  typers[43] = dao__gsl_vector_long_double_view_Typer,
  typers[44] = dao__gsl_vector_long_view_Typer,
  typers[45] = dao__gsl_vector_short_const_view_Typer,
  typers[46] = dao__gsl_vector_short_view_Typer,
  typers[47] = dao__gsl_vector_uchar_const_view_Typer,
  typers[48] = dao__gsl_vector_uchar_view_Typer,
  typers[49] = dao__gsl_vector_uint_const_view_Typer,
  typers[50] = dao__gsl_vector_uint_view_Typer,
  typers[51] = dao__gsl_vector_ulong_const_view_Typer,
  typers[52] = dao__gsl_vector_ulong_view_Typer,
  typers[53] = dao__gsl_vector_ushort_const_view_Typer,
  typers[54] = dao__gsl_vector_ushort_view_Typer,
  typers[55] = dao__gsl_vector_view_Typer,
  typers[56] = dao_gsl_block_Typer,
  typers[57] = dao_gsl_block_char_Typer,
  typers[58] = dao_gsl_block_complex_Typer,
  typers[59] = dao_gsl_block_complex_float_Typer,
  typers[60] = dao_gsl_block_complex_long_double_Typer,
  typers[61] = dao_gsl_block_float_Typer,
  typers[62] = dao_gsl_block_int_Typer,
  typers[63] = dao_gsl_block_long_Typer,
  typers[64] = dao_gsl_block_long_double_Typer,
  typers[65] = dao_gsl_block_short_Typer,
  typers[66] = dao_gsl_block_uchar_Typer,
  typers[67] = dao_gsl_block_uint_Typer,
  typers[68] = dao_gsl_block_ulong_Typer,
  typers[69] = dao_gsl_block_ushort_Typer,
  typers[70] = dao_gsl_complex_Typer,
  typers[71] = dao_gsl_complex_float_Typer,
  typers[72] = dao_gsl_complex_long_double_Typer,
  typers[73] = dao_gsl_error_handler_t_Typer,
  typers[74] = dao_gsl_ieee_double_rep_Typer,
  typers[75] = dao_gsl_ieee_float_rep_Typer,
  typers[76] = dao_gsl_matrix_Typer,
  typers[77] = dao_gsl_matrix_char_Typer,
  typers[78] = dao_gsl_matrix_complex_Typer,
  typers[79] = dao_gsl_matrix_complex_float_Typer,
  typers[80] = dao_gsl_matrix_complex_long_double_Typer,
  typers[81] = dao_gsl_matrix_float_Typer,
  typers[82] = dao_gsl_matrix_int_Typer,
  typers[83] = dao_gsl_matrix_long_Typer,
  typers[84] = dao_gsl_matrix_long_double_Typer,
  typers[85] = dao_gsl_matrix_short_Typer,
  typers[86] = dao_gsl_matrix_uchar_Typer,
  typers[87] = dao_gsl_matrix_uint_Typer,
  typers[88] = dao_gsl_matrix_ulong_Typer,
  typers[89] = dao_gsl_matrix_ushort_Typer,
  typers[90] = dao_gsl_stream_handler_t_Typer,
  typers[91] = dao_gsl_vector_Typer,
  typers[92] = dao_gsl_vector_char_Typer,
  typers[93] = dao_gsl_vector_complex_Typer,
  typers[94] = dao_gsl_vector_complex_float_Typer,
  typers[95] = dao_gsl_vector_complex_long_double_Typer,
  typers[96] = dao_gsl_vector_float_Typer,
  typers[97] = dao_gsl_vector_int_Typer,
  typers[98] = dao_gsl_vector_long_Typer,
  typers[99] = dao_gsl_vector_long_double_Typer,
  typers[100] = dao_gsl_vector_short_Typer,
  typers[101] = dao_gsl_vector_uchar_Typer,
  typers[102] = dao_gsl_vector_uint_Typer,
  typers[103] = dao_gsl_vector_ulong_Typer,
  typers[104] = dao_gsl_vector_ushort_Typer,
  typers[105] = NULL;
  aliases[0] = NULL;
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_array" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_array_long_double" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_long_double" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_long_double_ptr" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_ptr" );
  DaoNameSpace_TypeDefine( ns, "float", "gsl_complex_packed_array_float" );
  DaoNameSpace_TypeDefine( ns, "float", "gsl_complex_packed_float" );
  DaoNameSpace_TypeDefine( ns, "float", "gsl_complex_packed_float_ptr" );
  DaoNameSpace_TypeDefine( ns, "int", "gsl_mode_t" );
  DaoNameSpace_TypeDefine( ns, "int", "gsl_prec_t" );
  DaoNameSpace_AddConstNumbers( ns, constNumbers );
  DaoNameSpace_WrapTypes( ns, typers );
  DaoNameSpace_WrapFunctions( ns, dao_Funcs );
  return 0;
}
#ifdef __cplusplus
}
#endif

